<!DOCTYPE html>
<html lang="zh-CN">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>JVM类加载机制详解 | 技术小馆</title>
    <link rel="stylesheet" href="https://cdn.staticfile.org/font-awesome/6.4.0/css/all.min.css">
    <link rel="stylesheet" href="https://cdn.staticfile.org/tailwindcss/2.2.19/tailwind.min.css">
    <link href="https://fonts.googleapis.com/css2?family=Noto+Serif+SC:wght@400;500;600;700&family=Noto+Sans+SC:wght@300;400;500;700&display=swap" rel="stylesheet">
    <script src="https://cdn.jsdelivr.net/npm/mermaid@latest/dist/mermaid.min.js"></script>
    <style>
        body {
            font-family: 'Noto Sans SC', Tahoma, Arial, Roboto, "Droid Sans", "Helvetica Neue", "Droid Sans Fallback", "Heiti SC", "Hiragino Sans GB", Simsun, sans-serif;
            color: #333;
            line-height: 1.6;
        }
        h1, h2, h3, h4 {
            font-family: 'Noto Serif SC', serif;
            font-weight: 600;
        }
        .hero-gradient {
            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
        }
        .card-hover {
            transition: all 0.3s ease;
        }
        .card-hover:hover {
            transform: translateY(-5px);
            box-shadow: 0 10px 25px rgba(0, 0, 0, 0.1);
        }
        .code-block {
            background-color: #f8f9fa;
            border-left: 4px solid #667eea;
            padding: 1rem;
            border-radius: 0 4px 4px 0;
            overflow-x: auto;
        }
        .diagram-container {
            background-color: #f8f9fa;
            padding: 1.5rem;
            border-radius: 8px;
            margin: 1.5rem 0;
        }
        .timeline-item {
            position: relative;
            padding-left: 2rem;
            margin-bottom: 2rem;
        }
        .timeline-item:before {
            content: '';
            position: absolute;
            left: 0;
            top: 0;
            width: 16px;
            height: 16px;
            border-radius: 50%;
            background-color: #667eea;
        }
        .timeline-item:after {
            content: '';
            position: absolute;
            left: 7px;
            top: 16px;
            bottom: -2rem;
            width: 2px;
            background-color: #e2e8f0;
        }
        .timeline-item:last-child:after {
            display: none;
        }
        .highlight-box {
            background-color: rgba(102, 126, 234, 0.1);
            border-left: 4px solid #667eea;
            padding: 1.5rem;
            border-radius: 0 4px 4px 0;
            margin: 1.5rem 0;
        }
    </style>
</head>
<body class="bg-gray-50">
    <!-- Hero Section -->
    <section class="hero-gradient text-white py-20 md:py-32 px-4">
        <div class="container mx-auto max-w-5xl">
            <div class="flex flex-col items-center text-center">
                <i class="fas fa-microchip text-5xl mb-6"></i>
                <h1 class="text-4xl md:text-5xl font-bold mb-4">深入理解JVM类加载机制</h1>
                <p class="text-xl md:text-2xl opacity-90 mb-8 max-w-3xl">探索Java类从字节码到运行的完整生命周期</p>
                <div class="flex space-x-4">
                    <a href="#introduction" class="px-6 py-3 bg-white text-indigo-700 rounded-lg font-medium hover:bg-gray-100 transition">开始阅读</a>
                    <a href="#diagrams" class="px-6 py-3 border border-white text-white rounded-lg font-medium hover:bg-white hover:bg-opacity-10 transition">可视化图表</a>
                </div>
            </div>
        </div>
    </section>

    <!-- Main Content -->
    <div class="container mx-auto max-w-5xl px-4 py-12">
        <!-- Introduction Section -->
        <section id="introduction" class="mb-16">
            <div class="flex items-center mb-8">
                <div class="w-2 h-8 bg-indigo-600 mr-4"></div>
                <h2 class="text-3xl font-bold">JVM类加载机制</h2>
            </div>
            <p class="text-lg mb-6 text-gray-700">
                作为Java开发者，我们经常会使用各种类和对象来实现功能，但你有没有思考过这些类是如何被加载到JVM（Java虚拟机）中的？类的加载机制是Java平台的基础，它不仅保证了类的正确加载和初始化，还对Java程序的性能、安全性和灵活性起到了至关重要的作用。
            </p>
            
            <div class="highlight-box mb-8">
                <p class="font-medium mb-2">关键理解</p>
                <p class="text-gray-700">
                    类的加载并不是一个简单的过程，而是由多个阶段组成的。这包括类的加载、验证、准备、解析、初始化和使用等环节。每一个阶段都在为确保类的正确性和有效性发挥着关键作用。
                </p>
            </div>
            
            <div class="grid md:grid-cols-2 gap-6 mb-8">
                <div class="bg-white p-6 rounded-xl shadow-sm card-hover">
                    <i class="fas fa-shield-alt text-indigo-600 text-2xl mb-4"></i>
                    <h3 class="text-xl font-semibold mb-3">验证阶段</h3>
                    <p class="text-gray-600">在验证阶段，JVM会检查字节码的正确性和安全性，以防止恶意代码的执行。</p>
                </div>
                <div class="bg-white p-6 rounded-xl shadow-sm card-hover">
                    <i class="fas fa-cog text-indigo-600 text-2xl mb-4"></i>
                    <h3 class="text-xl font-semibold mb-3">初始化阶段</h3>
                    <p class="text-gray-600">在初始化阶段，JVM会执行类的静态初始化块和静态变量的初始化，以确保类在使用前处于正确的状态。</p>
                </div>
            </div>
            
            <p class="text-gray-700 mb-6">
                Java中的类加载器是一个非常灵活且强大的机制，负责将类文件加载到JVM中。默认情况下，Java提供了多种类加载器，如启动类加载器、扩展类加载器和应用类加载器。而在一些复杂的应用场景中，我们还可以自定义类加载器，以实现热部署、模块化和插件化等高级功能。
            </p>
        </section>

        <!-- Class Loader Section -->
        <section id="class-loader" class="mb-16">
            <div class="flex items-center mb-8">
                <div class="w-2 h-8 bg-indigo-600 mr-4"></div>
                <h2 class="text-3xl font-bold">类加载器的作用</h2>
            </div>
            
            <p class="text-gray-700 mb-6">
                类加载器（ClassLoader）是Java虚拟机（JVM）的一部分，负责将类文件（通常是.class文件）加载到内存中，并转换为Java中的<code>Class</code>对象。类加载器将类的字节码从各种来源（如文件系统、网络、JAR文件等）加载到JVM，使其能够被程序使用。
            </p>
            
            <div class="grid md:grid-cols-2 gap-6 mb-8">
                <div class="bg-white p-6 rounded-xl shadow-sm card-hover">
                    <h3 class="text-xl font-semibold mb-3 flex items-center">
                        <i class="fas fa-file-upload text-indigo-600 mr-3"></i> 
                        加载类文件
                    </h3>
                    <ul class="list-disc pl-5 text-gray-600">
                        <li class="mb-2"><strong>从不同来源加载类文件：</strong>类加载器可以从多种来源加载类文件，如文件系统、JAR文件、网络位置等。</li>
                        <li><strong>解析类文件：</strong>类加载器将类文件的字节码转换为JVM可以识别和使用的<code>Class</code>对象。</li>
                    </ul>
                </div>
                <div class="bg-white p-6 rounded-xl shadow-sm card-hover">
                    <h3 class="text-xl font-semibold mb-3 flex items-center">
                        <i class="fas fa-sitemap text-indigo-600 mr-3"></i>
                        命名空间隔离
                    </h3>
                    <ul class="list-disc pl-5 text-gray-600">
                        <li class="mb-2"><strong>类命名空间：</strong>每个类加载器都有自己的命名空间，加载的类在这个命名空间中独立存在。</li>
                        <li><strong>避免类冲突：</strong>通过命名空间隔离，类加载器可以防止类冲突和重复加载。</li>
                    </ul>
                </div>
                <div class="bg-white p-6 rounded-xl shadow-sm card-hover">
                    <h3 class="text-xl font-semibold mb-3 flex items-center">
                        <i class="fas fa-bolt text-indigo-600 mr-3"></i>
                        动态加载和热部署
                    </h3>
                    <ul class="list-disc pl-5 text-gray-600">
                        <li class="mb-2"><strong>动态加载类：</strong>类加载器允许在程序运行时动态加载类。</li>
                        <li><strong>热部署：</strong>自定义类加载器可以实现类的热部署，即在不停止JVM的情况下更新类定义。</li>
                    </ul>
                </div>
                <div class="bg-white p-6 rounded-xl shadow-sm card-hover">
                    <h3 class="text-xl font-semibold mb-3 flex items-center">
                        <i class="fas fa-lock text-indigo-600 mr-3"></i>
                        安全性
                    </h3>
                    <ul class="list-disc pl-5 text-gray-600">
                        <li class="mb-2"><strong>双亲委派模型：</strong>类加载器采用双亲委派模型，首先将类加载请求委派给父加载器。</li>
                        <li><strong>安全管理：</strong>类加载器可以与Java的安全管理器（SecurityManager）配合，限制和控制类的加载来源和行为。</li>
                    </ul>
                </div>
            </div>
        </section>

        <!-- Lifecycle Section -->
        <section id="lifecycle" class="mb-16">
            <div class="flex items-center mb-8">
                <div class="w-2 h-8 bg-indigo-600 mr-4"></div>
                <h2 class="text-3xl font-bold">类加载的生命周期</h2>
            </div>
            
            <p class="text-gray-700 mb-6">
                类加载的生命周期是一个复杂且有序的过程，涉及多个阶段，每个阶段都有其特定的任务和作用。
            </p>
            
            <div id="diagrams" class="diagram-container mb-8">
                <div class="mermaid">
                    graph LR
                    A[加载 Loading] --> B[验证 Verification]
                    B --> C[准备 Preparation]
                    C --> D[解析 Resolution]
                    D --> E[初始化 Initialization]
                    E --> F[使用 Using]
                    F --> G[卸载 Unloading]
                </div>
            </div>
            
            <div class="timeline-container">
                <div class="timeline-item">
                    <h3 class="text-xl font-semibold mb-2">1. 加载（Loading）</h3>
                    <p class="text-gray-600">
                        加载阶段是类加载的起点，主要任务是通过类加载器将类的二进制数据读入内存，并创建一个代表这个类的<code>Class</code>对象。
                    </p>
                    <ul class="list-disc pl-5 mt-2 text-gray-600">
                        <li class="mb-1"><strong>字节码的获取：</strong>类加载器通过类的全限定名找到类的字节码。</li>
                        <li class="mb-1"><strong>创建Class对象：</strong>JVM使用这些字节码数据创建一个<code>Class</code>对象。</li>
                        <li><strong>缓存机制：</strong>为了优化性能，加载过的类通常会被缓存。</li>
                    </ul>
                </div>
                
                <div class="timeline-item">
                    <h3 class="text-xl font-semibold mb-2">2. 验证（Verification）</h3>
                    <p class="text-gray-600">
                        验证阶段的目的是确保加载的类的字节码符合JVM的规范，保证类的安全性和正确性。
                    </p>
                    <ul class="list-disc pl-5 mt-2 text-gray-600">
                        <li class="mb-1"><strong>文件格式验证：</strong>检查字节码文件的整体格式。</li>
                        <li class="mb-1"><strong>元数据验证：</strong>检查类的元数据，包括类的继承关系、方法签名等。</li>
                        <li class="mb-1"><strong>字节码验证：</strong>检查方法的字节码，确保不会出现数据类型错误等问题。</li>
                        <li><strong>符号引用验证：</strong>确保类、字段、方法的符号引用在解析时能够成功找到相应的目标。</li>
                    </ul>
                </div>
                
                <div class="timeline-item">
                    <h3 class="text-xl font-semibold mb-2">3. 准备（Preparation）</h3>
                    <p class="text-gray-600">
                        准备阶段是为类的静态变量分配内存，并将其初始化为默认值。
                    </p>
                    <ul class="list-disc pl-5 mt-2 text-gray-600">
                        <li class="mb-1"><strong>静态变量内存分配：</strong>JVM为类的静态变量分配内存空间。</li>
                        <li><strong>默认值初始化：</strong>静态变量会被初始化为JVM规范规定的默认值。</li>
                    </ul>
                </div>
                
                <div class="timeline-item">
                    <h3 class="text-xl font-semibold mb-2">4. 解析（Resolution）</h3>
                    <p class="text-gray-600">
                        解析阶段是将常量池中的符号引用替换为直接引用的过程。
                    </p>
                    <ul class="list-disc pl-5 mt-2 text-gray-600">
                        <li class="mb-1"><strong>类或接口的解析：</strong>将类或接口的符号引用解析为实际的类或接口对象。</li>
                        <li class="mb-1"><strong>字段解析：</strong>将字段的符号引用解析为具体的字段对象。</li>
                        <li><strong>方法解析：</strong>将方法的符号引用解析为具体的方法对象。</li>
                    </ul>
                </div>
                
                <div class="timeline-item">
                    <h3 class="text-xl font-semibold mb-2">5. 初始化（Initialization）</h3>
                    <p class="text-gray-600">
                        初始化阶段是执行类的初始化代码的过程。
                    </p>
                    <ul class="list-disc pl-5 mt-2 text-gray-600">
                        <li class="mb-1"><strong>静态变量赋值：</strong>静态变量会被赋值为用户在类定义中指定的值。</li>
                        <li class="mb-1"><strong>静态代码块执行：</strong>JVM会按顺序执行类中的静态代码块。</li>
                        <li><strong>类初始化的时机：</strong>类初始化通常在类首次主动使用时触发。</li>
                    </ul>
                </div>
                
                <div class="timeline-item">
                    <h3 class="text-xl font-semibold mb-2">6. 使用（Using）</h3>
                    <p class="text-gray-600">
                        使用阶段是类被应用程序实际使用的阶段。
                    </p>
                    <ul class="list-disc pl-5 mt-2 text-gray-600">
                        <li class="mb-1"><strong>创建实例：</strong>可以使用<code>new</code>关键字创建类的实例。</li>
                        <li class="mb-1"><strong>调用静态方法和访问静态变量：</strong>可以调用类的静态方法和访问类的静态变量。</li>
                        <li><strong>反射操作：</strong>可以通过反射机制动态创建类的实例、调用方法和访问字段。</li>
                    </ul>
                </div>
                
                <div class="timeline-item">
                    <h3 class="text-xl font-semibold mb-2">7. 卸载（Unloading）</h3>
                    <p class="text-gray-600">
                        卸载阶段是JVM释放类及其相关资源的过程。
                    </p>
                    <ul class="list-disc pl-5 mt-2 text-gray-600">
                        <li class="mb-1"><strong>类的卸载条件：</strong>类的卸载通常发生在类加载器本身被卸载时。</li>
                        <li><strong>释放资源：</strong>卸载类时，JVM会释放该类占用的内存空间。</li>
                    </ul>
                </div>
            </div>
        </section>

        <!-- Class Loader Types Section -->
        <section id="loader-types" class="mb-16">
            <div class="flex items-center mb-8">
                <div class="w-2 h-8 bg-indigo-600 mr-4"></div>
                <h2 class="text-3xl font-bold">类加载器的类型</h2>
            </div>
            
            <p class="text-gray-700 mb-6">
                在Java虚拟机（JVM）中，类加载器（ClassLoader）是负责将类文件加载到内存并转换为<code>Class</code>对象的关键组件。Java提供了多种类加载器，每种加载器在系统中扮演着不同的角色，并具有各自独特的功能和应用场景。
            </p>
            
            <div class="diagram-container mb-8">
                <div class="mermaid">
                    graph TD
                    A[启动类加载器] --> B[扩展类加载器]
                    B --> C[应用类加载器]
                    C --> D[自定义类加载器]
                </div>
            </div>
            
            <div class="grid md:grid-cols-2 gap-6 mb-8">
                <div class="bg-white p-6 rounded-xl shadow-sm card-hover">
                    <h3 class="text-xl font-semibold mb-3 flex items-center">
                        <i class="fas fa-rocket text-indigo-600 mr-3"></i>
                        启动类加载器（Bootstrap ClassLoader）
                    </h3>
                    <ul class="list-disc pl-5 text-gray-600">
                        <li class="mb-1"><strong>原生实现：</strong>由本地代码实现，是JVM自带的一部分。</li>
                        <li class="mb-1"><strong>无父加载器：</strong>是类加载器层次结构的根。</li>
                        <li><strong>加载核心类库：</strong>负责加载<code>rt.jar</code>、<code>charsets.jar</code>等核心类库。</li>
                    </ul>
                </div>
                <div class="bg-white p-6 rounded-xl shadow-sm card-hover">
                    <h3 class="text-xl font-semibold mb-3 flex items-center">
                        <i class="fas fa-expand text-indigo-600 mr-3"></i>
                        扩展类加载器（Extension ClassLoader）
                    </h3>
                    <ul class="list-disc pl-5 text-gray-600">
                        <li class="mb-1"><strong>Java实现：</strong>由Java语言实现，继承自<code>java.lang.ClassLoader</code>。</li>
                        <li class="mb-1"><strong>父加载器为启动类加载器</strong></li>
                        <li><strong>加载扩展类库：</strong>主要用于加载扩展目录中的类和资源。</li>
                    </ul>
                </div>
                <div class="bg-white p-6 rounded-xl shadow-sm card-hover">
                    <h3 class="text-xl font-semibold mb-3 flex items-center">
                        <i class="fas fa-laptop-code text-indigo-600 mr-3"></i>
                        应用类加载器（Application ClassLoader）
                    </h3>
                    <ul class="list-disc pl-5 text-gray-600">
                        <li class="mb-1"><strong>Java实现：</strong>通常是<code>sun.misc.Launcher$AppClassLoader</code>类。</li>
                        <li class="mb-1"><strong>父加载器为扩展类加载器</strong></li>
                        <li><strong>加载应用程序类：</strong>主要用于加载用户的应用程序代码和库文件。</li>
                    </ul>
                </div>
                <div class="bg-white p-6 rounded-xl shadow-sm card-hover">
                    <h3 class="text-xl font-semibold mb-3 flex items-center">
                        <i class="fas fa-cogs text-indigo-600 mr-3"></i>
                        自定义类加载器（Custom ClassLoader）
                    </h3>
                    <ul class="list-disc pl-5 text-gray-600">
                        <li class="mb-1"><strong>用户实现：</strong>由用户继承<code>java.lang.ClassLoader</code>并实现其方法。</li>
                        <li class="mb-1"><strong>灵活性：</strong>可以根据需求实现类的加载逻辑。</li>
                        <li><strong>父加载器可指定：</strong>可以指定其父加载器，形成层次结构。</li>
                    </ul>
                </div>
            </div>
        </section>

        <!-- Class Loader Working Principle Section -->
        <section id="working-principle" class="mb-16">
            <div class="flex items-center mb-8">
                <div class="w-2 h-8 bg-indigo-600 mr-4"></div>
                <h2 class="text-3xl font-bold">类加载器的工作原理</h2>
            </div>
            
            <p class="text-gray-700 mb-6">
                类加载器（ClassLoader）是Java虚拟机（JVM）中一个重要的组件，负责将类文件加载到内存并转换为Java中的<code>Class</code>对象。类加载器的工作原理不仅涉及类的加载过程，还涉及到双亲委派模型、命名空间管理以及类缓存等多个方面。
            </p>
            
            <div class="highlight-box mb-8">
                <h3 class="text-xl font-semibold mb-3 flex items-center">
                    <i class="fas fa-sitemap text-indigo-600 mr-3"></i>
                    双亲委派模型（Parent Delegation Model）
                </h3>
                <p class="text-gray-700 mb-3">
                    双亲委派模型是类加载器的一个重要机制，旨在确保Java核心类库的安全性和稳定性。
                </p>
                <ul class="list-disc pl-5 text-gray-700">
                    <li class="mb-1"><strong>委派机制：</strong>当类加载器收到类加载请求时，它首先将请求委派给父类加载器处理。</li>
                    <li class="mb-1"><strong>优点：</strong>防止用户自定义的类加载器覆盖或替换Java核心类库，提高系统安全性。</li>
                </ul>
            </div>
            
            <div class="grid md:grid-cols-2 gap-6 mb-8">
                <div class="bg-white p-6 rounded-xl shadow-sm card-hover">
                    <h3 class="text-xl font-semibold mb-3 flex items-center">
                        <i class="fas fa-project-diagram text-indigo-600 mr-3"></i>
                        命名空间管理
                    </h3>
                    <ul class="list-disc pl-5 text-gray-600">
                        <li class="mb-1"><strong>命名空间隔离：</strong>每个类加载器都有自己的命名空间，加载的类在这个命名空间中独立存在。</li>
                        <li><strong>类唯一性：</strong>同一个类在不同类加载器中被加载会被视为不同的类，即使它们的字节码完全相同。</li>
                    </ul>
                </div>
                <div class="bg-white p-6 rounded-xl shadow-sm card-hover">
                    <h3 class="text-xl font-semibold mb-3 flex items-center">
                        <i class="fas fa-database text-indigo-600 mr-3"></i>
                        类缓存机制
                    </h3>
                    <ul class="list-disc pl-5 text-gray-600">
                        <li class="mb-1"><strong>提高加载效率：</strong>避免重复加载已经加载过的类，减少类加载的开销。</li>
                        <li><strong>一致性：</strong>确保同一个类在同一个类加载器中只会被加载一次。</li>
                    </ul>
                </div>
            </div>
            
            <div class="code-block mb-8">
                <p class="font-medium text-gray-700 mb-2">双亲委派模型代码示例</p>
                <pre class="text-gray-800"><code>public Class&lt;?&gt; loadClass(String name) throws ClassNotFoundException {
    // 1. 检查是否已加载
    Class&lt;?&gt; c = findLoadedClass(name);
    if (c == null) {
        try {
            // 2. 委托给父类加载器
            if (parent != null) {
                c = parent.loadClass(name);
            } else {
                c = findBootstrapClassOrNull(name);
            }
        } catch (ClassNotFoundException e) {
            // 3. 父类加载器无法加载，尝试自己加载
            c = findClass(name);
        }
    }
    return c;
}</code></pre>
            </div>
        </section>

        <!-- Custom Class Loader Section -->
        <section id="custom-loader" class="mb-16">
            <div class="flex items-center mb-8">
                <div class="w-2 h-8 bg-indigo-600 mr-4"></div>
                <h2 class="text-3xl font-bold">自定义类加载器</h2>
            </div>
            
            <p class="text-gray-700 mb-6">
                虽然JVM提供了默认的类加载机制，但有时我们需要根据特定需求实现自定义类加载器。自定义类加载器允许我们从不同来源加载类，如网络、数据库、加密文件等，同时也能实现模块化和隔离等高级功能。
            </p>
            
            <div class="highlight-box mb-8">
                <h3 class="text-xl font-semibold mb-3">自定义类加载器的应用场景</h3>
                <div class="grid md:grid-cols-2 gap-4">
                    <div>
                        <h4 class="font-medium text-gray-700 mb-2 flex items-center">
                            <i class="fas fa-puzzle-piece text-indigo-600 mr-2"></i>
                            模块化系统
                        </h4>
                        <p class="text-gray-600">在大型企业应用中，使用自定义类加载器可以实现模块化，每个模块有自己的类加载器，确保模块之间的类隔离。</p>
                    </div>
                    <div>
                        <h4 class="font-medium text-gray-700 mb-2 flex items-center">
                            <i class="fas fa-plug text-indigo-600 mr-2"></i>
                            插件系统
                        </h4>
                        <p class="text-gray-600">插件系统需要动态加载和卸载插件，每个插件可能由不同的开发者提供，自定义类加载器确保插件之间的隔离和独立性。</p>
                    </div>
                    <div>
                        <h4 class="font-medium text-gray-700 mb-2 flex items-center">
                            <i class="fas fa-code-branch text-indigo-600 mr-2"></i>
                            多版本支持
                        </h4>
                        <p class="text-gray-600">在同一JVM中同时运行同一个库的多个版本，通过自定义类加载器可以实现类版本的隔离，避免版本冲突。</p>
                    </div>
                    <div>
                        <h4 class="font-medium text-gray-700 mb-2 flex items-center">
                            <i class="fas fa-network-wired text-indigo-600 mr-2"></i>
                            非传统来源加载
                        </h4>
                        <p class="text-gray-600">自定义类加载器可以从文件系统以外的来源加载类，如网络、数据库、加密文件等，满足特定应用场景的需求。</p>
                    </div>
                </div>
            </div>
            
            <div class="code-block mb-8">
                <p class="font-medium text-gray-700 mb-2">自定义类加载器示例</p>
                <pre class="text-gray-800"><code>public class CustomClassLoader extends ClassLoader {
    private String classPath;

    public CustomClassLoader(String classPath) {
        this.classPath = classPath;
    }

    @Override
    protected Class&lt;?&gt; findClass(String name) throws ClassNotFoundException {
        try {
            String fileName = classPath + name.replace('.', '/') + ".class";
            byte[] classData = Files.readAllBytes(Paths.get(fileName));
            return defineClass(name, classData, 0, classData.length);
        } catch (IOException e) {
            throw new ClassNotFoundException(name, e);
        }
    }

    public static void main(String[] args) throws Exception {
        CustomClassLoader loader = new CustomClassLoader("path/to/classes/");
        Class&lt;?&gt; clazz = loader.loadClass("com.ts.MyClass");
        Object instance = clazz.newInstance();
        System.out.println(instance.getClass().getName());
    }
}</code></pre>
            </div>
            
            <div class="grid md:grid-cols-2 gap-6">
                <div class="bg-white p-6 rounded-xl shadow-sm card-hover">
                    <h3 class="text-xl font-semibold mb-3">缓存机制</h3>
                    <p class="text-gray-600">
                        为了提高性能，自定义类加载器可以实现类的缓存机制，避免重复加载同一个类。可以使用<code>ConcurrentHashMap</code>或其他数据结构来缓存已经加载的类。
                    </p>
                </div>
                <div class="bg-white p-6 rounded-xl shadow-sm card-hover">
                    <h3 class="text-xl font-semibold mb-3">动态重加载</h3>
                    <p class="text-gray-600">
                        在某些场景下，可能需要动态重加载类，以支持代码热替换或版本更新。自定义类加载器可以实现动态重加载机制，在需要时重新加载类的字节码。
                    </p>
                </div>
            </div>
        </section>
    </div>

    <!-- Footer -->
    <footer class="bg-gray-900 text-white py-12 px-4">
        <div class="container mx-auto max-w-5xl">
            <div class="flex flex-col items-center">
                <h3 class="text-xl font-semibold mb-4">技术小馆</h3>
                <a href="http://www.yuque.com/jtostring" class="text-indigo-300 hover:text-white transition">http://www.yuque.com/jtostring</a>
                <div class="mt-6 flex space-x-4">
                    <a href="#" class="text-gray-400 hover:text-white transition"><i class="fab fa-github text-xl"></i></a>
                    <a href="#" class="text-gray-400 hover:text-white transition"><i class="fab fa-twitter text-xl"></i></a>
                    <a href="#" class="text-gray-400 hover:text-white transition"><i class="fab fa-linkedin text-xl"></i></a>
                </div>
            </div>
        </div>
    </footer>

    <script>
        mermaid.initialize({
            startOnLoad: true,
            theme: 'default',
            flowchart: {
                useMaxWidth: true,
                htmlLabels: true,
                curve: 'basis'
            }
        });
        
        // 平滑滚动
        document.querySelectorAll('a[href^="#"]').forEach(anchor => {
            anchor.addEventListener('click', function (e) {
                e.preventDefault();
                document.querySelector(this.getAttribute('href')).scrollIntoView({
                    behavior: 'smooth'
                });
            });
        });
    </script>
</body>
</html>